package org.example.word;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池
 * @author yanglizdf
 */
public class WordPoolManager {
    private static class SingletonHelper {
        private static final WordPoolManager threadPoolManager = new WordPoolManager();
    }
    /** 线程池维护线程的最少数量*/
    private static final int SIZE_CORE_POOL = 5;
    /**线程池维护线程的最大数量*/
    private static final int SIZE_MAX_POOL =  5;

    /**
     * 线程池
     *
     * @param corePoolSize - 池中所保存的线程数，包括空闲线程。
     * @param maximumPoolSize - 池中允许的最大线程数。
     * @param keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
     * @param unit - keepAliveTime 参数的时间单位。
     * @param workQueue - 执行前用于保持任务的队列。此队列仅由保持 execute 方法提交的 Runnable 任务。
     * @param handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
     */
    private static final ThreadPoolExecutor mThreadPool = new ThreadPoolExecutor(SIZE_CORE_POOL, SIZE_MAX_POOL, 0L,
            TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(200));

    public static WordPoolManager newInstance() {
        return SingletonHelper.threadPoolManager;
    }

    public static ThreadPoolExecutor getThreadPoolInstance(){
        return mThreadPool;
    }

    /**
     * 初始化
     */
    public void prepare() {
        mThreadPool.setKeepAliveTime(10, TimeUnit.SECONDS);
        mThreadPool.allowCoreThreadTimeOut(true);
        if (mThreadPool.isShutdown() && !mThreadPool.prestartCoreThread()) {
            @SuppressWarnings("unused")
            int startThread = mThreadPool.prestartAllCoreThreads();
        }
    }

    /**
     * 添加任务
     *
     * @param task
     */
    public void addExecuteTask(Runnable task) {
        if (task != null) {
            mThreadPool.execute(task);
        }
    }

    /**
     * 判断是否最后一个任务
     *
     * @return
     */
    public boolean isTaskEnd() {
        return mThreadPool.getActiveCount() == 0;
    }

    /**
     * 获取缓存大小
     *
     * @return
     */
    public int getQueue() {
        return mThreadPool.getQueue().size();
    }

    /**
     * 获取线程数量
     *
     * @return
     */
    public int getPoolSize() {
        return mThreadPool.getPoolSize();
    }

    /**
     * 获取已完成任务数
     *
     * @return
     */
    public long getCompletedTaskCount() {
        return mThreadPool.getCompletedTaskCount();
    }

    /**
     * 关闭线程池
     */
    public void shutdown() {
        mThreadPool.shutdown();
    }

}
